package _11_整理题目._0_工具集;

import java.util.*;
import java.util.stream.*;

/**
 * 常用的类和方法
 * Scanner sc = new Scanner(System.in)
 *      .nextInt()
 *      .nextLine()
 *
 * StringBuilder sb = new StringBuilder("hello")
 *      .append()
 *      .deleteCharAt()
 *      .reverse()
 *      .toString()
 *      .length()
 *
 * String str = new String(char[])
 *      .toLowerCase()
 *      .toUpperCase()
 *      .toCharArray()
 *      .charAt()
 *      .substring()
 *      .split("\\.")
 *      .split("-")
 *      .replace( , )       替换 字符 或 字符串
 *      .replaceAll( , )    根据正则表达式替换
 *      .trim()             去掉 首尾 的空格
 *      .contains(String)
 *      .length()
 *      .compareTo()        按字典序比较
 *
 * Integer
 *      .valueOf()
 *      .parseInt()
 *
 * Character
 *      .isLetterOrDigit()
 *      .isDigit()
 *      .isLetter()
 *      .isUpperCase()
 *      .isLowerCase()
 *      .toUpperCase()
 *      .toLowerCase()
 *
 * Random rd = new Random()
 *      .nexInt(10)  // 生成一个 [0,9] 之间的随机数
 *
 * Arrays
 *      .fill(arr, n)
 *      .sort(arr, new Comparator)
 *      .copyOf()
 *      .copyOfRange()
 *      .stream(arr)
 *
 * Stream
 *      Arrays.stream(arr)
 *      Xxx.stream()
 *
 *      .sort()
 *      .distinct()
 *      .filter(e -> e>5)
 *      .mapToInt(Integer::valueOf)
 *
 *      .toArray()
 *      .collect(collectors.toList())
 *
 *
 * Collections.sor(list)
 * Integer max =  Collections.max(list)
 * Integer min =  Collections.min(list)
 *
 *
 * 常用的数据结构类和方法，转 数组 的方法
 *      任意 Xxx<Integer> 转 int[] 数组： .stream().mapToInt(Integer.valueOf).toArray();
 *      任意 Xxx<String> 转 String[] 数组：.toArray(new String[.size()]);
 * List<Integer> list = new ArrayList<>()
 *      .add(obj)
 *      .addAll(list)
 *      .get(i)
 *      .remove(i)
 *      .remove(obj)
 *      .set(i, obj)
 *      .contains()
 *      .size()
 *      .isEmpty()
 *                  // List<Integer> 转 int[]
 *      .stream().mapToInt(Integer::valueOf).toArray();
 *                  // List<String> 转 String[]
 *      .toArray(new String[list.size()]);
 *
 * Set<Integer> set = new HashSet<>()
 *      .add()
 *      .remove()
 *      .contains()
 *      .size()
 *      .isEmpty()
 *                  // Set<Integer> 转 int[]
 *      .stream().mapToInt(Integer::valueOf).toArray();
 *                  // Set<String> 转 String[]
 *      .toArray(new String[set.size()]);
 *
 * Map<Integer, Integer> map = new HashMap<>()
 *      .put(k, v)
 *      .get(k)
 *      .getOrDefault(k, default)
 *      .remove(k)
 *      .containsKey(k)
 *      .keySet()
 *      .size()
 *      .isEmpty()
 *
 * Stack<Integer> stack = new Stack<>()
 *      .push()
 *      .pop()
 *      .peek()
 *      .size()
 *      .isEmpty()
 *                  // Set<Integer> 转 int[]
 *      .stream().mapToInt(Integer::valueOf).toArray();
 *                  // Set<String> 转 String[]
 *      .toArray(new String[set.size()]);
 *
 * Queue<Integer> queue = new LinkedList<>()
 *      .offer()
 *      .poll()
 *      .peek()
 *      .size()
 *      .isEmpty()
 *                  // Set<Integer> 转 int[]
 *      .stream().mapToInt(Integer::valueOf).toArray();
 *                  // Set<String> 转 String[]
 *      .toArray(new String[set.size()]);
 *
 * Deque<Integer> deque = new LinkedList<>()
 *      .offerFirst()
 *      .offerLast()
 *      .pollFirst()
 *      .pollLast()
 *      .peekFirst()
 *      .peekLast()
 *      .size()
 *      .isEmpty()
 *                  // Set<Integer> 转 int[]
 *      .stream().mapToInt(Integer::valueOf).toArray();
 *                  // Set<String> 转 String[]
 *      .toArray(new String[set.size()]);
 *
 * PriorityQueue<Integer> queue = new PriorityQueue<>()
 *      .offer()
 *      .poll()
 *      .peek()
 *      .size()
 *      .isEmpty()
 *                  // Set<Integer> 转 int[]
 *      .stream().mapToInt(Integer::valueOf).toArray();
 *                  // Set<String> 转 String[]
 *      .toArray(new String[set.size()]);
 *
 *
 * 排序比较：大小堆排序  二维数组排序
 * PriorityQueue<Integer> queue = new PriorityQueue<>() // 小根堆，peek 是最小值
 * PriorityQueue<Integer> queue = new PriorityQueue<>((a,b)->b-a) // 大根堆，peek 是最大值
 * Arrays.sort(array, new )
 * Arrays.sort(array, () -> {})
 *
 * 复制数组：
 *      void    System.arraycopy(src, srcPos, dest, destPos, length)
 *      []      Arrays.copyOfRange(src, from, to)
 *      []      Arrays.copyOf(src, length)
 *
 * 1.8 新特性：
 *      新增了 流操作 ，可以直接将 数组 其他的数据结构转为 stream，
 *      然后使用 stream 类提供的方法处理流中的每一个对象，
 *      （比如 排序 sorted 过滤 filter 映射 mapToXxx 切片 limit 等）
 *      最后收集成 数组 或 集合 list set 返回。
 *
 *      第二个可以使用 函数式接口，方法引用，lambda 表达式，可以使代码更简洁
 *      函数式接口是只有一个抽象方法，可以有多个默认方法，可以隐式转为 lambda 表达式，
 *      比如 Comparator 就是一个 @FunctionalInterface；
 *      方法应用是类似 c++ 使用 :: 引用方法，
 *      比如 foreach 的时候可以使用 foreach(System.out::println)；
 *      lambda 表达式主要可以改善以前匿名内部类的写法，使得写法更加简洁，
 *      比如 二维数组排序的时候，传入的匿名比较器类。
 *
 *      第三个是默认方法 可以在接口中实现一些 具体的方法，使用 default 修饰
 *      它的出现是为了解决版本升级，接口兼容性的问题。
 *      因为之前的接口里只能有抽象方法，使得接口和实现类的耦合太高，一旦修改接口，
 *      所有的实现类都要改，1.8 为了升级接口，并且向前兼容，所以实现了默认方法。
 *
 */
public class _666_总结 {
    public static void main(String[] args) {

    }
}
